package com.storm.config.rest

import org.springframework.http.HttpEntity
import org.springframework.http.HttpHeaders
import org.springframework.http.HttpMethod
import org.springframework.http.ResponseEntity
import org.springframework.stereotype.Component
import org.springframework.stereotype.Service
import org.springframework.web.client.RestTemplate

/**
 * RestTemplate 远程调用工具类
 *
 * @author Logan
 * @createDate 2019-02-08
 */

class RestTemplateComponent(val restTemplate: RestTemplate) {

    // ----------------------------------GET-------------------------------------------------------
    /**
     * GET请求调用方式
     *
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @return ResponseEntity 响应对象封装类
     */
    operator fun <T> get(url: String, responseType: Class<T>): ResponseEntity<T> {
        return restTemplate.getForEntity(url, responseType)
    }

    /**
     * GET请求调用方式
     *
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    operator fun <T> get(url: String, responseType: Class<T>, vararg uriVariables: Any): ResponseEntity<T> {
        return restTemplate.getForEntity(url, responseType, *uriVariables)
    }

    /**
     * GET请求调用方式
     *
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    operator fun <T> get(url: String, responseType: Class<T>, uriVariables: Map<String, *>): ResponseEntity<T> {
        return restTemplate.getForEntity(url, responseType, uriVariables)
    }

    /**
     * 带请求头的GET请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    operator fun <T> get(
        url: String,
        headers: Map<String, String>,
        responseType: Class<T>,
        vararg uriVariables: Any
    ): ResponseEntity<T> {
        val httpHeaders = HttpHeaders()
        httpHeaders.setAll(headers)
        return get(url, httpHeaders, responseType, *uriVariables)
    }

    /**
     * 带请求头的GET请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    operator fun <T> get(
        url: String,
        headers: HttpHeaders,
        responseType: Class<T>,
        vararg uriVariables: Any
    ): ResponseEntity<T> {
        val requestEntity: HttpEntity<*> = HttpEntity<Any>(headers)
        return exchange(url, HttpMethod.GET, requestEntity, responseType, *uriVariables)
    }

    /**
     * 带请求头的GET请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    operator fun <T> get(
        url: String,
        headers: Map<String, String>,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        val httpHeaders = HttpHeaders()
        httpHeaders.setAll(headers)
        return get(url, httpHeaders, responseType, uriVariables)        
    }

    /**
     * 带请求头的GET请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    operator fun <T> get(
        url: String,
        headers: HttpHeaders,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        val requestEntity: HttpEntity<*> = HttpEntity<Any>(headers)
        return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables)
    }
    // ----------------------------------POST-------------------------------------------------------
    /**
     * POST请求调用方式
     *
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @return
     */
    fun <T> post(url: String, responseType: Class<T>): ResponseEntity<T> {
        return restTemplate.postForEntity(url, HttpEntity.EMPTY, responseType)
    }

    /**
     * POST请求调用方式
     *
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> post(url: String, requestBody: Any, responseType: Class<T>): ResponseEntity<T> {
        return restTemplate.postForEntity(url, requestBody, responseType)
    }

    /**
     * POST请求调用方式
     *
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> post(
        url: String,
        requestBody: Any,
        responseType: Class<T>,
        vararg uriVariables: Any
    ): ResponseEntity<T> {
        return restTemplate.postForEntity(url, requestBody, responseType, *uriVariables)
    }

    /**
     * POST请求调用方式
     *
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> post(
        url: String,
        requestBody: Any,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        return restTemplate.postForEntity(url, requestBody, responseType, uriVariables)
    }

    /**
     * 带请求头的POST请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> post(
        url: String,
        headers: Map<String, String>,
        requestBody: Any,
        responseType: Class<T>,
        vararg uriVariables: Any
    ): ResponseEntity<T> {
        val httpHeaders = HttpHeaders()
        httpHeaders.setAll(headers)
        return post(url, httpHeaders, requestBody, responseType, *uriVariables)
    }

    /**
     * 带请求头的POST请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> post(
        url: String,
        headers: HttpHeaders,
        requestBody: Any,
        responseType: Class<T>,
        vararg uriVariables: Any
    ): ResponseEntity<T> {
        val requestEntity = HttpEntity(requestBody, headers)
        return post(url, requestEntity, responseType, *uriVariables)
    }

    /**
     * 带请求头的POST请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> post(
        url: String,
        headers: Map<String, String>,
        requestBody: Any,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        val httpHeaders = HttpHeaders()
        httpHeaders.setAll(headers)
        return post(url, httpHeaders, requestBody, responseType, uriVariables)
    }

    /**
     * 带请求头的POST请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> post(
        url: String,
        headers: HttpHeaders,
        requestBody: Any,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        val requestEntity = HttpEntity(requestBody, headers)
        return post(url, requestEntity, responseType, uriVariables)
    }

    /**
     * 自定义请求头和请求体的POST请求调用方式
     *
     * @param url 请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> post(
        url: String,
        requestEntity: HttpEntity<*>,
        responseType: Class<T>,
        vararg uriVariables: Any
    ): ResponseEntity<T> {
        return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, *uriVariables)
    }

    /**
     * 自定义请求头和请求体的POST请求调用方式
     *
     * @param url 请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> post(
        url: String,
        requestEntity: HttpEntity<*>,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables)
    }
    // ----------------------------------PUT-------------------------------------------------------
    /**
     * PUT请求调用方式
     *
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> put(url: String, responseType: Class<T>, vararg uriVariables: Any): ResponseEntity<T> {
        return put(url, HttpEntity.EMPTY, responseType, *uriVariables)
    }

    /**
     * PUT请求调用方式
     *
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> put(url: String, requestBody: Any, responseType: Class<T>, vararg uriVariables: Any): ResponseEntity<T> {
        val requestEntity = HttpEntity(requestBody)
        return put(url, requestEntity, responseType, *uriVariables)
    }

    /**
     * PUT请求调用方式
     *
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> put(
        url: String,
        requestBody: Any,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        val requestEntity = HttpEntity(requestBody)
        return put(url, requestEntity, responseType, uriVariables)
    }

    /**
     * 带请求头的PUT请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> put(
        url: String,
        headers: Map<String, String>,
        requestBody: Any,
        responseType: Class<T>,
        vararg uriVariables: Any
    ): ResponseEntity<T> {
        val httpHeaders = HttpHeaders()
        httpHeaders.setAll(headers)
        return put(url, httpHeaders, requestBody, responseType, *uriVariables)
    }

    /**
     * 带请求头的PUT请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> put(
        url: String,
        headers: HttpHeaders,
        requestBody: Any,
        responseType: Class<T>,
        vararg uriVariables: Any
    ): ResponseEntity<T> {
        val requestEntity = HttpEntity(requestBody, headers)
        return put(url, requestEntity, responseType, *uriVariables)
    }

    /**
     * 带请求头的PUT请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> put(
        url: String,
        headers: Map<String, String>,
        requestBody: Any,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        val httpHeaders = HttpHeaders()
        httpHeaders.setAll(headers)
        return put(url, httpHeaders, requestBody, responseType, uriVariables)
    }

    /**
     * 带请求头的PUT请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> put(
        url: String,
        headers: HttpHeaders,
        requestBody: Any,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        val requestEntity = HttpEntity(requestBody, headers)
        return put(url, requestEntity, responseType, uriVariables)
    }

    /**
     * 自定义请求头和请求体的PUT请求调用方式
     *
     * @param url 请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> put(
        url: String,
        requestEntity: HttpEntity<*>,
        responseType: Class<T>,
        vararg uriVariables: Any
    ): ResponseEntity<T> {
        return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, *uriVariables)
    }

    /**
     * 自定义请求头和请求体的PUT请求调用方式
     *
     * @param url 请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> put(
        url: String,
        requestEntity: HttpEntity<*>,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables)
    }
    // ----------------------------------DELETE-------------------------------------------------------
    /**
     * DELETE请求调用方式
     *
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> delete(url: String, responseType: Class<T>, vararg uriVariables: Any): ResponseEntity<T> {
        return delete(url, HttpEntity.EMPTY, responseType, *uriVariables)
    }

    /**
     * DELETE请求调用方式
     *
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> delete(url: String, responseType: Class<T>, uriVariables: Map<String, *>): ResponseEntity<T> {
        return delete(url, HttpEntity.EMPTY, responseType, uriVariables)
    }

    /**
     * DELETE请求调用方式
     *
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> delete(
        url: String,
        requestBody: Any,
        responseType: Class<T>,
        vararg uriVariables: Any
    ): ResponseEntity<T> {
        val requestEntity = HttpEntity(requestBody)
        return delete(url, requestEntity, responseType, *uriVariables)
    }

    /**
     * DELETE请求调用方式
     *
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> delete(
        url: String,
        requestBody: Any,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        val requestEntity = HttpEntity(requestBody)
        return delete(url, requestEntity, responseType, uriVariables)
    }

    /**
     * 带请求头的DELETE请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> delete(
        url: String,
        headers: Map<String, String>,
        responseType: Class<T>,
        vararg uriVariables: Any
    ): ResponseEntity<T> {
        val httpHeaders = HttpHeaders()
        httpHeaders.setAll(headers)
        return delete(url, httpHeaders, responseType, *uriVariables)
    }

    /**
     * 带请求头的DELETE请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> delete(
        url: String,
        headers: HttpHeaders,
        responseType: Class<T>,
        vararg uriVariables: Any
    ): ResponseEntity<T> {
        val requestEntity = HttpEntity<Any>(headers)
        return delete(url, requestEntity, responseType, *uriVariables)
    }

    /**
     * 带请求头的DELETE请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> delete(
        url: String,
        headers: Map<String, String>,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        val httpHeaders = HttpHeaders()
        httpHeaders.setAll(headers)
        return delete(url, httpHeaders, responseType, uriVariables)
    }

    /**
     * 带请求头的DELETE请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> delete(
        url: String,
        headers: HttpHeaders,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        val requestEntity = HttpEntity<Any>(headers)
        return delete(url, requestEntity, responseType, uriVariables)
    }

    /**
     * 带请求头的DELETE请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> delete(
        url: String,
        headers: Map<String, String>,
        requestBody: Any,
        responseType: Class<T>,
        vararg uriVariables: Any
    ): ResponseEntity<T> {
        val httpHeaders = HttpHeaders()
        httpHeaders.setAll(headers)
        return delete(url, httpHeaders, requestBody, responseType, *uriVariables)
    }

    /**
     * 带请求头的DELETE请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> delete(
        url: String,
        headers: HttpHeaders,
        requestBody: Any,
        responseType: Class<T>,
        vararg uriVariables: Any
    ): ResponseEntity<T> {
        val requestEntity = HttpEntity(requestBody, headers)
        return delete(url, requestEntity, responseType, *uriVariables)
    }

    /**
     * 带请求头的DELETE请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> delete(
        url: String,
        headers: Map<String, String>,
        requestBody: Any,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        val httpHeaders = HttpHeaders()
        httpHeaders.setAll(headers)
        return delete(url, httpHeaders, requestBody, responseType, uriVariables)
    }

    /**
     * 带请求头的DELETE请求调用方式
     *
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> delete(
        url: String,
        headers: HttpHeaders,
        requestBody: Any,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        val requestEntity = HttpEntity(requestBody, headers)
        return delete(url, requestEntity, responseType, uriVariables)
    }

    /**
     * 自定义请求头和请求体的DELETE请求调用方式
     *
     * @param url 请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> delete(
        url: String,
        requestEntity: HttpEntity<*>,
        responseType: Class<T>,
        vararg uriVariables: Any
    ): ResponseEntity<T> {
        return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, *uriVariables)
    }

    /**
     * 自定义请求头和请求体的DELETE请求调用方式
     *
     * @param url 请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> delete(
        url: String,
        requestEntity: HttpEntity<*>,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables)
    }
    // ----------------------------------通用方法-------------------------------------------------------
    /**
     * 通用调用方式
     *
     * @param url 请求URL
     * @param method 请求方法类型
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> exchange(
        url: String,
        method: HttpMethod,
        requestEntity: HttpEntity<*>,
        responseType: Class<T>,
        vararg uriVariables: Any
    ): ResponseEntity<T> {
        return restTemplate.exchange(url, method, requestEntity, responseType, *uriVariables)
    }

    /**
     * 通用调用方式
     *
     * @param url 请求URL
     * @param method 请求方法类型
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    fun <T> exchange(
        url: String,
        method: HttpMethod,
        requestEntity: HttpEntity<*>,
        responseType: Class<T>,
        uriVariables: Map<String, *>
    ): ResponseEntity<T> {
        return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables)
    }
}